#include "mainwindow.h"
#include "ui_mainwindow.h"

struct contador {
    QColor cor;
    int quantidade;
};

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    ui->graphicsView->setScene(&cena);
    cena.addItem(&img);

}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::Abrir() {

    about.clear();
    diretorio = QFileDialog::getOpenFileName( this, "Abrir Imagem", QDir::homePath() + "/Pictures" , tr("Imagem BMP (*.bmp);;Imagem YUV (*.yuv)" ));
    if ( diretorio.isEmpty()) {
        qDebug() << "MainWindow::abrirMapa: nao foi selecionado nenhum arquivo";
        return;
    }

    if (img.ler(diretorio, &about)) {               // passa o diretorio e o sobre para a imagem
        cena.setSceneRect(img.boundingRect());      // seta desenho da cena como a imagem
        cena.update();

        qDebug() << "Ok";
    }
    else {
        qDebug() << "bugou";
    }

    return;
}

void MainWindow::ReAbrir() {
    about.clear();
    if (img.ler(diretorio, &about)) {
        cena.setSceneRect(img.boundingRect());
        cena.update();

        qDebug() << "Ok";
    }
    else {
        qDebug() << "Imagem Ainda Nao Selecionada";
    }

    return;
}

void MainWindow::Salvar() {

    QString fileDir = QFileDialog::getSaveFileName( this, "Salvar BMP", QDir::currentPath(), tr("Imagem BMP (*.bmp)"));

    if (fileDir.isEmpty()) {
        qDebug () << "Local nao especificado";
        return;
    }

    QByteArray b;
    b.append(img.getBytes());           // pega os bytes da imagem

    qDebug() << "Return ok";
    QFile file (fileDir);
    if ( !file.open(QIODevice::WriteOnly) ) {
        qDebug() << "Nao foi possivel abrir arquivo para salvar";
        return;
    }

    file.write(b);
    file.close();
    qDebug() << "Salvo com sucesso";

}

void MainWindow::Cinza() {
    for (int a = 0; a < img.getAltura() ; ++a) {
        for (int l = 0; l < img.getLargura(); ++l) {
            QColor cor = img.getCor(a,l);                               // pega a cor na posicao
            short cinza = (cor.red() + cor.green() + cor.blue())/3;     // calcula a media
            cor.setRed(cinza);
            cor.setBlue(cinza);
            cor.setGreen(cinza);

            img.setCor(a,l,cor);                                        // seta a cor na mesma posicao
        }
    }

    img.updateMapa();
    qDebug() << "Cinza";
    cena.update();

}

void MainWindow::PretoeBranco() {
    for (int a = 0; a < img.getAltura() ; ++a) {
        for (int l = 0; l < img.getLargura(); ++l) {
            QColor cor = img.getCor(a,l);
            if (((cor.red() + cor.green() + cor.blue())/3) > 127 ) {        // branco
                cor.setRed(255);
                cor.setBlue(255);
                cor.setGreen(255);
                img.setCor(a,l,cor);
            }
            else {                                              // preto
                cor.setRed(0);
                cor.setBlue(0);
                cor.setGreen(0);
                img.setCor(a,l,cor);
            }
        }
    }

    img.updateMapa();
    cena.update();
    qDebug() << "Preto e Branco";

}

void MainWindow::Negativo() {
    for (int a = 0; a < img.getAltura() ; ++a) {
        for (int l = 0; l < img.getLargura(); ++l) {
            QColor cor = img.getCor(a,l);
            cor.setRed(255-cor.red());
            cor.setBlue(255-cor.blue());
            cor.setGreen(255-cor.green());

            img.setCor(a,l,cor);
        }
    }

    img.updateMapa();
    qDebug() << "Negativo";
    cena.update();
}

void MainWindow::media() {
/*
 *  ( 1   1   1 )
 *  ( 1   1   1 )   /9
 *  ( 1   1   1 )
 */

    for (int a = 0; a < img.getAltura() ; ++a) {
        for (int l = 0; l < img.getLargura() ; ++l) {

            if (a == 0 && l == 0) {                 // caso seja a primeira posicao
                QColor mascara[4];
                mascara [0] = img.getCor(0,0);
                mascara [1] = img.getCor(0,1);
                mascara [2] = img.getCor(1,0);
                mascara [3] = img.getCor(1,1);

                double resultadoR = ((mascara[0].red()) + (mascara[1].red()) + (mascara[2].red()) + (mascara[3].red()))/4;
                double resultadoG = ((mascara[0].green()) + (mascara[1].green()) + (mascara[2].green()) + (mascara[3].green()))/4;
                double resultadoB = ((mascara[0].blue()) + (mascara[1].blue()) + (mascara[2].blue()) + (mascara[3].blue()))/4;

                QColor cor;
                cor.setRed((int) resultadoR);
                cor.setGreen((int) resultadoG);
                cor.setBlue((int)resultadoB);

                img.setCor(0,0,cor);
                continue;
            }

            if (a == 0 && l == (img.getLargura()-1)) {      // caso seja primeira linha ultima coluna
                int largura = img.getLargura()-1;
                QColor mascara[4];
                mascara [0] = img.getCor(0,largura);
                mascara [1] = img.getCor(0,largura-1);
                mascara [2] = img.getCor(1,largura);
                mascara [3] = img.getCor(1,largura-1);

                double resultadoR = ((mascara[0].red()) + (mascara[1].red()) + (mascara[2].red()) + (mascara[3].red()))/4;
                double resultadoG = ((mascara[0].green()) + (mascara[1].green()) + (mascara[2].green()) + (mascara[3].green()))/4;
                double resultadoB = ((mascara[0].blue()) + (mascara[1].blue()) + (mascara[2].blue()) + (mascara[3].blue()))/4;

                QColor cor;
                cor.setRed((int) resultadoR);
                cor.setGreen((int) resultadoG);
                cor.setBlue((int)resultadoB);

                img.setCor(0,largura,cor);
                continue;
            }

            if (a == (img.getAltura()-1) && l == 0) {       // caso seja ultima linha primeira coluna
                int altura = img.getAltura()-1;
                QColor mascara[4];
                mascara [0] = img.getCor(altura,0);
                mascara [1] = img.getCor(altura,1);
                mascara [2] = img.getCor(altura-1,0);
                mascara [3] = img.getCor(altura-1,1);

                double resultadoR = ((mascara[0].red()) + (mascara[1].red()) + (mascara[2].red()) + (mascara[3].red()))/4;
                double resultadoG = ((mascara[0].green()) + (mascara[1].green()) + (mascara[2].green()) + (mascara[3].green()))/4;
                double resultadoB = ((mascara[0].blue()) + (mascara[1].blue()) + (mascara[2].blue()) + (mascara[3].blue()))/4;

                QColor cor;
                cor.setRed((int) resultadoR);
                cor.setGreen((int) resultadoG);
                cor.setBlue((int)resultadoB);

                img.setCor(altura,0,cor);
                continue;
            }

            if (a == (img.getAltura()-1) && l == img.getLargura()-1) {  // caso seja ultima linha e ultima coluna
                int altura = img.getAltura()-1;
                int largura = img.getLargura()-1;
                QColor mascara[4];
                mascara [0] = img.getCor(altura,largura);
                mascara [1] = img.getCor(altura,largura-1);
                mascara [2] = img.getCor(altura-1,largura);
                mascara [3] = img.getCor(altura-1,largura-1);

                double resultadoR = ((mascara[0].red()) + (mascara[1].red()) + (mascara[2].red()) + (mascara[3].red()))/4;
                double resultadoG = ((mascara[0].green()) + (mascara[1].green()) + (mascara[2].green()) + (mascara[3].green()))/4;
                double resultadoB = ((mascara[0].blue()) + (mascara[1].blue()) + (mascara[2].blue()) + (mascara[3].blue()))/4;

                QColor cor;
                cor.setRed((int) resultadoR);
                cor.setGreen((int) resultadoG);
                cor.setBlue((int)resultadoB);

                img.setCor(altura,largura,cor);
                continue;
            }

            if (a == 0) {                       // caso seja borda superior
                QColor mascara[6];
                mascara [0] = img.getCor(0,l-1);
                mascara [1] = img.getCor(0,l);
                mascara [2] = img.getCor(0,l+1);
                mascara [3] = img.getCor(1,l-1);
                mascara [4] = img.getCor(1,l);
                mascara [5] = img.getCor(1,l+1);

                double resultadoR = ((mascara[0].red()) + (mascara[1].red()) + (mascara[2].red()) + (mascara[3].red()) + (mascara[4].red()) + (mascara[5].red()))/6;
                double resultadoG = ((mascara[0].green()) + (mascara[1].green()) + (mascara[2].green()) + (mascara[3].green()) + (mascara[4].green()) + (mascara[5].green()))/6;
                double resultadoB = ((mascara[0].blue()) + (mascara[1].blue()) + (mascara[2].blue()) + (mascara[3].blue()) + (mascara[4].blue()) + (mascara[5].blue()))/6;

                QColor cor;
                cor.setRed((int) resultadoR);
                cor.setGreen((int) resultadoG);
                cor.setBlue((int)resultadoB);

                img.setCor(0,l,cor);
                continue;
            }

            if (l == 0) {                   // caso seja borda da esquerda
                QColor mascara[6];
                mascara [0] = img.getCor(a-1,0);
                mascara [1] = img.getCor(a,0);
                mascara [2] = img.getCor(a+1,0);
                mascara [3] = img.getCor(a-1,1);
                mascara [4] = img.getCor(a,1);
                mascara [5] = img.getCor(a+1,1);

                double resultadoR = ((mascara[0].red()) + (mascara[1].red()) + (mascara[2].red()) + (mascara[3].red()) + (mascara[4].red()) + (mascara[5].red()))/6;
                double resultadoG = ((mascara[0].green()) + (mascara[1].green()) + (mascara[2].green()) + (mascara[3].green()) + (mascara[4].green()) + (mascara[5].green()))/6;
                double resultadoB = ((mascara[0].blue()) + (mascara[1].blue()) + (mascara[2].blue()) + (mascara[3].blue()) + (mascara[4].blue()) + (mascara[5].blue()))/6;

                QColor cor;
                cor.setRed((int) resultadoR);
                cor.setGreen((int) resultadoG);
                cor.setBlue((int)resultadoB);

                img.setCor(a,0,cor);
                continue;
            }

            if (a == img.getAltura()-1) {           // caso seja borda inferior
                int altura = img.getAltura()-1;
                QColor mascara[6];
                mascara [0] = img.getCor(altura,l-1);
                mascara [1] = img.getCor(altura,l);
                mascara [2] = img.getCor(altura,l+1);
                mascara [3] = img.getCor(altura-1,l-1);
                mascara [4] = img.getCor(altura-1,l);
                mascara [5] = img.getCor(altura-1,l+1);

                double resultadoR = ((mascara[0].red()) + (mascara[1].red()) + (mascara[2].red()) + (mascara[3].red()) + (mascara[4].red()) + (mascara[5].red()))/6;
                double resultadoG = ((mascara[0].green()) + (mascara[1].green()) + (mascara[2].green()) + (mascara[3].green()) + (mascara[4].green()) + (mascara[5].green()))/6;
                double resultadoB = ((mascara[0].blue()) + (mascara[1].blue()) + (mascara[2].blue()) + (mascara[3].blue()) + (mascara[4].blue()) + (mascara[5].blue()))/6;

                QColor cor;
                cor.setRed((int) resultadoR);
                cor.setGreen((int) resultadoG);
                cor.setBlue((int)resultadoB);

                img.setCor(altura,l,cor);
                continue;
            }

            if (l == img.getLargura()-1) {          // caso seja borda da direita
                int largura = img.getLargura()-1;
                QColor mascara[6];
                mascara [0] = img.getCor(a-1,largura);
                mascara [1] = img.getCor(a,largura);
                mascara [2] = img.getCor(a+1,largura);
                mascara [3] = img.getCor(a-1,largura-1);
                mascara [4] = img.getCor(a,largura-1);
                mascara [5] = img.getCor(a+1,largura-1);

                double resultadoR = ((mascara[0].red()) + (mascara[1].red()) + (mascara[2].red()) + (mascara[3].red()) + (mascara[4].red()) + (mascara[5].red()))/6;
                double resultadoG = ((mascara[0].green()) + (mascara[1].green()) + (mascara[2].green()) + (mascara[3].green()) + (mascara[4].green()) + (mascara[5].green()))/6;
                double resultadoB = ((mascara[0].blue()) + (mascara[1].blue()) + (mascara[2].blue()) + (mascara[3].blue()) + (mascara[4].blue()) + (mascara[5].blue()))/6;

                QColor cor;
                cor.setRed((int) resultadoR);
                cor.setGreen((int) resultadoG);
                cor.setBlue((int)resultadoB);

                img.setCor(a,largura,cor);
                continue;
            }
                                                         // demais locais
            QColor mascara[9];
            mascara [0] = img.getCor(a-1,l-1);
            mascara [1] = img.getCor(a-1,l);
            mascara [2] = img.getCor(a-1,l+1);
            mascara [3] = img.getCor(a,l-1);
            mascara [4] = img.getCor(a,l);
            mascara [5] = img.getCor(a,l+1);
            mascara [6] = img.getCor(a+1,l-1);
            mascara [7] = img.getCor(a+1,l);
            mascara [8] = img.getCor(a+1,l+1);

            double resultadoR = ((mascara[0].red()) + (mascara[1].red()) + (mascara[2].red()) +
                                 (mascara[3].red()) + (mascara[4].red()) + (mascara[5].red()) +
                                 (mascara[6].red()) + (mascara[7].red()) + (mascara[8].red()))/9;
            double resultadoG = ((mascara[0].green()) + (mascara[1].green()) + (mascara[2].green()) +
                                 (mascara[3].green()) + (mascara[4].green()) + (mascara[5].green()) +
                                 (mascara[6].green()) + (mascara[7].green()) + (mascara[8].green()))/9;
            double resultadoB = ((mascara[0].blue()) + (mascara[1].blue()) + (mascara[2].blue()) +
                                 (mascara[3].blue()) + (mascara[4].blue()) + (mascara[4].blue()) +
                                 (mascara[6].blue()) + (mascara[7].blue()) + (mascara[8].blue()))/9;

            QColor cor;
            cor.setRed((int) resultadoR);
            cor.setGreen((int) resultadoG);
            cor.setBlue((int)resultadoB);

            img.setCor(a,l,cor);
        }
    }

    img.updateMapa();
    qDebug() << "Media";
    cena.update();
}

void MainWindow::sobre() {

    const QString titulo = "Sobre";

    if (diretorio == NULL) {
        QMessageBox mensagem;
        mensagem.about(this, titulo, "Imagem ainda não aberta");
        mensagem.exec();

        return;
    }

    QMessageBox mensagem;
    mensagem.about(this, titulo, about);
    mensagem.exec();

}

void MainWindow::sobelHorizontal() {
    int div = 4;
    int mask[3][3] = {
        {-1, -2, -1},
        {0,  0,  0},
        {1,  2,  1}};

        for (int a = 1; a < img.getAltura()-1 ; ++a) {
            for (int l = 1; l < img.getLargura()-1 ; ++l) {

                QColor** mascara = setMatriz(a, l, 3);


                double resultadoR = ((mascara[0][0].red()*mask[0][0]) + (mascara[0][1].red()*mask[0][1]) + (mascara[0][2].red()*mask[0][2]) +
                                     (mascara[1][0].red()*mask[1][0]) + (mascara[1][1].red()*mask[1][1]) + (mascara[1][2].red()*mask[1][2]) +
                                     (mascara[2][0].red()*mask[2][0]) + (mascara[2][1].red()*mask[2][1]) + (mascara[2][2].red())*mask[2][2]) / div;

                double resultadoG = ((mascara[0][0].green()*mask[0][0]) + (mascara[0][1].green()*mask[0][1]) + (mascara[0][2].green()*mask[0][2]) +
                                     (mascara[1][0].green()*mask[1][0]) + (mascara[1][1].green()*mask[1][1]) + (mascara[1][2].green()*mask[1][2]) +
                                     (mascara[2][0].green()*mask[2][0]) + (mascara[2][1].green()*mask[2][1]) + (mascara[2][2].green())*mask[2][2]) / div;

                double resultadoB = ((mascara[0][0].blue()*mask[0][0]) + (mascara[0][1].blue()*mask[0][1]) + (mascara[0][2].blue()*mask[0][2]) +
                                     (mascara[1][0].blue()*mask[1][0]) + (mascara[1][1].blue()*mask[1][1]) + (mascara[1][2].blue()*mask[1][2]) +
                                     (mascara[2][0].blue()*mask[2][0]) + (mascara[2][1].blue()*mask[2][1]) + (mascara[2][2].blue())*mask[2][2]) / div;

                QColor cor;
                cor.setRed(validaNum(resultadoR));
                cor.setGreen(validaNum(resultadoG));
                cor.setBlue(validaNum(resultadoB));

                img.setCor(a,l,cor);
            }
        }

        img.updateMapa();
        qDebug() << "Sobel Horizontal";
        cena.update();
}

void MainWindow::sobelVertical() {
    int div = 4;
    int mask[3][3] = {
        {1,  0,  -1},
        {2,  0,  -2},
        {1,  0,  -1}};

        for (int a = 1; a < img.getAltura()-1 ; ++a) {
            for (int l = 1; l < img.getLargura()-1 ; ++l) {

                QColor** mascara = setMatriz(a, l, 3);


                double resultadoR = ((mascara[0][0].red()*mask[0][0]) + (mascara[0][1].red()*mask[0][1]) + (mascara[0][2].red()*mask[0][2]) +
                                     (mascara[1][0].red()*mask[1][0]) + (mascara[1][1].red()*mask[1][1]) + (mascara[1][2].red()*mask[1][2]) +
                                     (mascara[2][0].red()*mask[2][0]) + (mascara[2][1].red()*mask[2][1]) + (mascara[2][2].red())*mask[2][2]) / div;

                double resultadoG = ((mascara[0][0].green()*mask[0][0]) + (mascara[0][1].green()*mask[0][1]) + (mascara[0][2].green()*mask[0][2]) +
                                     (mascara[1][0].green()*mask[1][0]) + (mascara[1][1].green()*mask[1][1]) + (mascara[1][2].green()*mask[1][2]) +
                                     (mascara[2][0].green()*mask[2][0]) + (mascara[2][1].green()*mask[2][1]) + (mascara[2][2].green())*mask[2][2]) / div;

                double resultadoB = ((mascara[0][0].blue()*mask[0][0]) + (mascara[0][1].blue()*mask[0][1]) + (mascara[0][2].blue()*mask[0][2]) +
                                     (mascara[1][0].blue()*mask[1][0]) + (mascara[1][1].blue()*mask[1][1]) + (mascara[1][2].blue()*mask[1][2]) +
                                     (mascara[2][0].blue()*mask[2][0]) + (mascara[2][1].blue()*mask[2][1]) + (mascara[2][2].blue())*mask[2][2]) / div;

                QColor cor;
                cor.setRed(validaNum(resultadoR));
                cor.setGreen(validaNum(resultadoG));
                cor.setBlue(validaNum(resultadoB));

                img.setCor(a,l,cor);
            }
        }

        img.updateMapa();
        qDebug() << "Sobel Vertical";
        cena.update();
}

void MainWindow::robertsHorizontal() {
    int div = 1;
    int mask[3][3] = {
        {-1, 0,  0},
        {0,  1,  0},
        {0,  0,  0}};

        for (int a = 1; a < img.getAltura()-1 ; ++a) {
            for (int l = 1; l < img.getLargura()-1 ; ++l) {

                QColor** mascara = setMatriz(a, l, 3);


                double resultadoR = ((mascara[0][0].red()*mask[0][0]) + (mascara[0][1].red()*mask[0][1]) + (mascara[0][2].red()*mask[0][2]) +
                                     (mascara[1][0].red()*mask[1][0]) + (mascara[1][1].red()*mask[1][1]) + (mascara[1][2].red()*mask[1][2]) +
                                     (mascara[2][0].red()*mask[2][0]) + (mascara[2][1].red()*mask[2][1]) + (mascara[2][2].red())*mask[2][2]) / div;

                double resultadoG = ((mascara[0][0].green()*mask[0][0]) + (mascara[0][1].green()*mask[0][1]) + (mascara[0][2].green()*mask[0][2]) +
                                     (mascara[1][0].green()*mask[1][0]) + (mascara[1][1].green()*mask[1][1]) + (mascara[1][2].green()*mask[1][2]) +
                                     (mascara[2][0].green()*mask[2][0]) + (mascara[2][1].green()*mask[2][1]) + (mascara[2][2].green())*mask[2][2]) / div;

                double resultadoB = ((mascara[0][0].blue()*mask[0][0]) + (mascara[0][1].blue()*mask[0][1]) + (mascara[0][2].blue()*mask[0][2]) +
                                     (mascara[1][0].blue()*mask[1][0]) + (mascara[1][1].blue()*mask[1][1]) + (mascara[1][2].blue()*mask[1][2]) +
                                     (mascara[2][0].blue()*mask[2][0]) + (mascara[2][1].blue()*mask[2][1]) + (mascara[2][2].blue())*mask[2][2]) / div;

                QColor cor;
                cor.setRed(validaNum(resultadoR));
                cor.setGreen(validaNum(resultadoG));
                cor.setBlue(validaNum(resultadoB));

                img.setCor(a,l,cor);
            }
        }

        img.updateMapa();
        qDebug() << "Roberts Horizontal";
        cena.update();
}

void MainWindow::robertsVertical() {
    int div = 1;
    int mask[3][3] = {
        {0,  0,  -1},
        {0,  1,  0},
        {0,  0,  0}};

        for (int a = 1; a < img.getAltura()-1 ; ++a) {
            for (int l = 1; l < img.getLargura()-1 ; ++l) {

                QColor** mascara = setMatriz(a, l, 3);


                double resultadoR = ((mascara[0][0].red()*mask[0][0]) + (mascara[0][1].red()*mask[0][1]) + (mascara[0][2].red()*mask[0][2]) +
                                     (mascara[1][0].red()*mask[1][0]) + (mascara[1][1].red()*mask[1][1]) + (mascara[1][2].red()*mask[1][2]) +
                                     (mascara[2][0].red()*mask[2][0]) + (mascara[2][1].red()*mask[2][1]) + (mascara[2][2].red())*mask[2][2]) / div;

                double resultadoG = ((mascara[0][0].green()*mask[0][0]) + (mascara[0][1].green()*mask[0][1]) + (mascara[0][2].green()*mask[0][2]) +
                                     (mascara[1][0].green()*mask[1][0]) + (mascara[1][1].green()*mask[1][1]) + (mascara[1][2].green()*mask[1][2]) +
                                     (mascara[2][0].green()*mask[2][0]) + (mascara[2][1].green()*mask[2][1]) + (mascara[2][2].green())*mask[2][2]) / div;

                double resultadoB = ((mascara[0][0].blue()*mask[0][0]) + (mascara[0][1].blue()*mask[0][1]) + (mascara[0][2].blue()*mask[0][2]) +
                                     (mascara[1][0].blue()*mask[1][0]) + (mascara[1][1].blue()*mask[1][1]) + (mascara[1][2].blue()*mask[1][2]) +
                                     (mascara[2][0].blue()*mask[2][0]) + (mascara[2][1].blue()*mask[2][1]) + (mascara[2][2].blue())*mask[2][2]) / div;

                QColor cor;
                cor.setRed(validaNum(resultadoR));
                cor.setGreen(validaNum(resultadoG));
                cor.setBlue(validaNum(resultadoB));

                img.setCor(a,l,cor);
            }
        }

        img.updateMapa();
        qDebug() << "Roberts Vertical";
        cena.update();
}

int MainWindow::validaNum(double val) {

    if (val > 255) return 255;
    if (val < 0) return 0;
    return (int)val;
}

void MainWindow::AND() {

    QString dir;
    dir = QFileDialog::getOpenFileName( this, "Abrir Imagem", QDir::homePath() + "/Pictures" , tr("Imagem BMP (*.bmp);;Imagem YUV (*.yuv)" ));
    if ( dir.isEmpty()) {
        qDebug() << "MainWindow::abrirMapa: nao foi selecionado nenhum arquivo";
        return;
    }

    if (img.AND(dir)) {               // passa o diretorio e o sobre para a imagem
        qDebug() << "AND Ok";
        cena.update();
    }
    else {
        qDebug() << "bugou";
    }

    return;

}

void MainWindow::OR() {
    QString dir;
    dir = QFileDialog::getOpenFileName( this, "Abrir Imagem", QDir::homePath() + "/Pictures" , tr("Imagem BMP (*.bmp);;Imagem YUV (*.yuv)" ));
    if ( dir.isEmpty()) {
        qDebug() << "MainWindow::abrirMapa: nao foi selecionado nenhum arquivo";
        return;
    }

    if (img.OR(dir)) {               // passa o diretorio e o sobre para a imagem
        qDebug() << "OR Ok";
        cena.update();
    }
    else {
        qDebug() << "bugou";
    }

    return;
}

QColor **MainWindow::setMatriz(int a, int l, int dimensao) {

    int metade = dimensao/2;

    QColor** saida = new QColor*[dimensao];
    for (int i = 0; i < dimensao; i++) {
        saida[i] = new QColor[dimensao];
    }

    int i2=0;
    int j2=0;
    for (int i = a-metade; i <= a+metade; i++) {
        for (int j=l-metade; j <= l+metade; j++) {
            saida[i2][j2] = img.getCor(i,j);
            j2++;
        }
        i2++;
        j2=0;
    }
    return saida;
}
